package lambda.jdkfunctioninterface.转换型;

import com.google.common.base.Function;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.IntFunction;
import java.util.function.Predicate;

import org.testng.annotations.Test;

/**
 *
 * Function<T,R>接口，接口根据一个类型的数据得到另一个数据类型的数据，前者为前置条件，后者为后置条件
 * function的含义是映射，就是用函数的方式将一个T类型的数据映射为R类型的数据
 * 一个函数式接口对象，就是一个可调用的处理逻辑
 *
 */
public class Function1 {



    public static void main(String[] args) {

    }

    /**
     * 使用test比放在main方法里执行更慢
     */
    @Test
    public static void t1() {
//        把字符映射成数字，定义的是一个逻辑，一个处理逻辑，后面使用的时候有一个具体的对象去调用唯一的方法
        Function<String, Integer> s = Integer::parseInt;
        Integer i = s.apply("12");
        System.out.println(i);

        // 把数字映射成字符
        Function<Integer, String> f2 = String::valueOf;
        f2.apply(13);

        Function<Integer, Boolean> f3 = i3 -> {
            return Math.random() > 0.5;

        };

        Function<Integer, Boolean> function = new Function<>() {
            @Override
            public Boolean apply(Integer integer) {
                return Math.random() > 0.5;
            }
        };
    }

    @Test
    public static void t2() {

        var comparator = Comparator.comparingDouble((String num) -> Double.parseDouble(num) + 1);

        var list = new ArrayList<String>();

        list.add("8");
        list.add("0");
        list.add("9");
        list.add("3");
        list.stream().sorted(comparator);
        System.out.println(list);

        var list2 = new ArrayList<String>();
        list2.add("8");
        list2.add("0");
        list2.add("9");
        list2.add("3");

        Comparator<String> reversed = comparator.reversed();

//        var l2 = list.stream().sorted(reversed)
//            .collect(Collectors.toList());

        var l2 = list.stream().sorted(reversed)
            .findFirst();

        // min取的依据是位置，取第一个位置，而非实际元素的大小
        var l3 = list.stream().max(reversed);

        System.out.println(l3);
    }

    @Test
    public void t3() {
        IntFunction<Integer> intFunction = i -> i + 1;
        System.out.println(intFunction.apply(1));


    }



}
